<!DOCTYPE html>
<html lang="zh-cn">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>openGauss Blog  | openGauss数据库核心技术-SQL引擎（2）</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">

    
    <link rel="shortcut icon" href="https://xzx666.gitee.io/lookeng/img/favicon.ico" type="image/x-icon" />
    <link rel="apple-touch-icon" href="https://xzx666.gitee.io/lookeng/img/apple-touch-icon.png" />

    <link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">

    
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css">
    <script src="https://cdn.bootcss.com/jquery/3.4.1/jquery.js"></script>
    
    <link rel="stylesheet" href="https://xzx666.gitee.io/lookeng/css/commen.css?t=1607593672000" />
    <link rel="stylesheet" href="https://xzx666.gitee.io/lookeng/css/blog.css?t=1607593672000" />
    <link rel="stylesheet" href="https://xzx666.gitee.io/lookeng/css/mobile.css?t=1607593672000" />
    <link rel="stylesheet" href="https://xzx666.gitee.io/lookeng/css/pagination.css?t=1607593672000">
    
    <script>
      var _hmt = _hmt || [];
      (function() {
        var hm = document.createElement("script");
        hm.src = "https://hm.baidu.com/hm.js?34e9f585f29581007941aa1698181871";
        var s = document.getElementsByTagName("script")[0]; 
        s.parentNode.insertBefore(hm, s);
      })();
    </script>
</head>
<body>
  <script src="//cdn1.lncld.net/static/js/3.0.4/av-min.js"></script>
  <script src='//unpkg.com/valine/dist/Valine.min.js'></script>






<div class="container">
    <div class="columns blog-detail">
        <div class="post_detail">
            <div class="is-child box">
                <div class="breadCrumb"><a href="\zh\">博客/</a></div>
                <div class="blog-detail-header">
                    <h1>openGauss数据库核心技术-SQL引擎（2）</h1>
                    <div class="blog-detail-prop">
                        <img src="https://xzx666.gitee.io/lookeng/img/icon-date.png">
                        <span class="article_right_date">2020-07-27</span>
                        <img src="https://xzx666.gitee.io/lookeng/img/icon-author.png">
                        <span class="article_right_author">kangyang</span>
                        <img src="https://xzx666.gitee.io/lookeng/img/icon-view.png">
                        <span id="/zh/post/kangyang/opengauss%E6%95%B0%E6%8D%AE%E5%BA%93%E6%A0%B8%E5%BF%83%E6%8A%80%E6%9C%AF-sql%E5%BC%95%E6%93%8E2/" class="leancloud_visitors" data-flag-title="openGauss数据库核心技术-SQL引擎（2）">
                            <i class="leancloud-visitors-count"></i>                     
                        </span>
                    </div>
                    <div class="blog-detail-tags">
                        <img src="https://xzx666.gitee.io/lookeng/img/icon-tag.png">
                        
                        <a href="https://xzx666.gitee.io/lookeng/zh/tags/opengauss%E6%95%B0%E6%8D%AE%E5%BA%93%E6%A0%B8%E5%BF%83%E6%8A%80%E6%9C%AF">openGauss数据库核心技术</a>
                        
                    </div>
                </div>
                <div class="content blog-content">
                    

<h2 id="前言">前言</h2>

<p>​   上期我们介绍了SQL解析的原理，并介绍了查询优化中查询重写的技术原理，本期将介绍路径搜索、代价计算的技术原理。</p>

<h2 id="路径搜索">路径搜索</h2>

<p>​   优化器最核心的问题是针对某个SQL语句获得其最优解，这个过程通常需要枚举SQL语句对应的解空间，也就是枚举不同的候选的执行路径，这些执行路径互相等价，但是执行效率不同，对解空间中的这些执行路径计算它们的执行代价，最终可以获得一个最优的执行路径。依据候选执行路径的搜索方法的不同，将优化器的结构划分为如下几种模式：</p>

<ul>
<li>自底向上模式：如图1所示，自底向上模式会对逻辑执行计划进行拆解，先建立对表的扫描算子，然后由扫描算子构成连接算子，最终堆成一个物理执行计划，在这个过程中，由于物理扫描算子和物理连接算子有多种可能，因此会生成多个物理执行路径，优化器会根据各个执行路径的估算代价选择出代价最低的执行计划，然后转交由执行器负责执行。</li>
</ul>

<p><strong>图1 自底向上模式</strong></p>

<p><img src="../figures/图1.png" alt="" /></p>

<ul>
<li>自顶向下模式：如图2所示，该模式总体是运用面向对象思路，将优化器核心功能对象化，在词法分析、语法分析、语义分析后生成逻辑计划。基于此逻辑计划，应用对象化的优化规则，产生多个待选的逻辑计划，通过采用自顶向下的方法遍历逻辑计划，结合动态规划、代价估算和分支限界技术，获得最优的执行路径。</li>
</ul>

<p><strong>图2 自顶向下模式</strong></p>

<p><img src="../figures/图2.png" alt="" /></p>

<ul>
<li>随机搜索模式：无论是自底向上模式还是自顶向下模式，在参与连接的表的数量比较多的情况下，都会出现枚举时间过长的问题，一些优化器在表比较多的情况下通过一些随机枚举的方法对路径进行搜索，尝试在随机的解空间中获得次优的执行计划。</li>
</ul>

<p>​   目前MySQL、PostgreSQL等数据库的优化器采用的是自底向上模式，SQL Server以及开源的Calcite、ORCA则采用了自顶向下模式，其中Calcite以良好的扩展性被广泛应用到其他开源项目里包括Apache Storm、Apache Flink、Apache Kylin、Apache Drill、SQL- Gremlin等项目。openGauss采用的是自底向上模式和随机搜索模式相结合的方式。</p>

<p>​   无论是自顶向下的搜索模式还是自底向上的搜索模式，搜索的过程也都是一个从逻辑执行计划向物理执行计划转变的过程，例如针对每个表可以有不同的扫描算子，而逻辑连接算子也可以转换为多种不同的物理连接算子，下面介绍一下具体的物理算子。</p>

<h3 id="单表扫描路径搜索">单表扫描路径搜索</h3>

<p>openGauss采用的是自底向上的路径搜索方法，因此路径生成总是从单表访问路径开始，对于单表访问路径，一般有两种：</p>

<ul>
<li>全表扫描：对表中的数据逐个访问。</li>
<li>索引扫描：借助索引来访问表中的数据，通常需要结合谓词一起使用。</li>
</ul>

<p>​   优化器首先根据表的数据量、过滤条件、可用的索引结合代价模型来估算各种不同扫描路径的代价。例如：给定表定义<code>CREATE TABLE t1(c1 int);</code>如果表中数据为1,2,3…100000000连续的整型值并且在c1列上有B+树索引，那么对于<code>SELECT * FROM t1 WHERE c1=1;</code>来说，只要读取1个索引页面和1个表页面就可以获取到数据。然而对于全表扫描，需要读取1亿条数据才能获取同样的结果。在这种情况下索引扫描的路径胜出。</p>

<p>​   索引扫描并不是在所有情况下都优于全表扫描，它们的优劣取决于过滤条件能够多滤掉多少数据，通常数据库管理系统会采用B+树来建立索引，如果在选择率比较高的情况下，B+树索引会带来大量的随机I/O，这会降低索引扫描算子的访问效率。比如<code>SELECT * FROM t1 WHERE c1&gt;0;</code>这条语句，索引扫描需要访问索引中的全部数据和表中的全部数据，并且带来巨量的随机I/O，而全表扫描只需要顺序的访问表中的全部数据，因此在这种情况下，全表扫描的代价更低。</p>

<h3 id="多表连接路径搜索">多表连接路径搜索</h3>

<p>​   多表路径生成的难点主要在于如何枚举所有的表连接顺序（Join Reorder）和连接算法（Join Algorithm）。假设有两个表t1和t2做JOIN操作，根据关系代数中的交换律原则，可以枚举的连接顺序有t1 × t2和t2 × t1两种，JOIN的物理连接算子有Hash Join、Nested Loop Join、Merge Join三种类型。这样一来，可供选择的路径有6种之多。这个数量随着表的增多会呈指数级增长，因此高效的搜索算法显得至关重要。</p>

<p>​   openGauss通常采用自底向上的路径搜索方法，首先生成了每个表的扫描路径，这些扫描路径在执行计划的最底层（第一层），在第二层开始考虑两表连接的最优路径，即枚举计算出每两表连接的可能性，在第三层考虑三表连接的最优路径，即枚举计算出三表连接的可能性，直到最顶层为止生成全局最优的执行计划。假设有4个表做JOIN操作，它们的连接路径生成过程如下：</p>

<ul>
<li>单表最优路径：依次生成{1}，{2}，{3}，{4}单表的最优路径。</li>
<li>二表最优路径：依次生成{1 2}，{1 3}，{1 4}，{2 3}，{2 4}，{3 4}的最优路径。</li>
<li>三表最优路径：依次生成{1 2 3}，{1 2 4}，{2 3 4}，{1 3 4}的最优路径。</li>
<li>四表最优路径：生成{1 2 3 4}的最优路径即为最终路径。</li>
</ul>

<p>​   多表路径问题核心为Join Order，这是NP（Nondeterministic Polynomially，非确定性多项式）类问题，在多个关系连接中找出最优路径，比较常用的算法是基于代价的动态规划算法，随着关联表个数的增多，会发生表搜索空间膨胀的问题，进而影响优化器路径选择的效率，可以采用基于代价的遗传算法等随机搜索算法来解决。</p>

<p>​   另外为了防止搜索空间过大，openGauss采用了三种剪枝策略：</p>

<ul>
<li>尽可能先考虑有连接条件的路径，尽量推迟笛卡尔积。</li>
<li>在搜索的过程中基于代价估算对执行路径采用LowBound剪枝，放弃一些代价较高的执行路径。</li>
<li>保留具有特殊物理属性的执行路径，例如有些执行路径的结果具有有序性的特点，这些执行路径可能在后序的优化过程中避免再次排序。</li>
</ul>

<h3 id="利用物理属性优化">利用物理属性优化</h3>

<p>​   关系的本身可以视为一个集合或者包，这种数据结构对数据的分布没有设定，为了提升计算的性能，我们需要借助一些数据结构或算法来对数据的分布做一些预处理，这些预处理方法或者利用了物理执行路径的物理属性（例如有序性），或者为物理执行路径创建物理属性，总之这些属性经常会在查询优化中发挥巨大的作用。</p>

<h4 id="b-树">B+树</h4>

<p>​   如果要查询一个表中的数据，最简单的办法自然是将表中的数据全部遍历一遍，但是随着当前数据量的越来越大，遍历表中数据的代价也越来越高，而B+树就成了我们高效的查询数据的有力武器。</p>

<p>​   1970年，R.Bayer和E.mccreight提出了一种适用于外查找的树，它是一种平衡的多叉树，称为B树，B树就是在表的数据上建立一个“目录”，类似于书籍中的目录，这样就能快速的定位到要查询的数据。</p>

<p>​   B+树作为一种数据结构和查询优化器本身没有直接的关系，但是数据库管理系统通常会建立基于B+树的索引，而在查询优化的过程中，可以通过索引扫描、位图扫描的方法提高查询效率，这都会涉及到这种B+树类型的索引的使用。</p>

<h4 id="hash表">Hash表</h4>

<p>​   Hash表也是一种对数据进行预处理的方法，openGauss数据库在多个地方使用了Hash表或借用了Hash表的思想来提升查询效率：</p>

<ul>
<li>借用Hash可以实现分组操作，因为Hash表天然就有对数据分类的功能。</li>
<li>借用Hash可以建立Hash索引，这种索引适用于等值的约束条件。</li>
<li>物理连接路径中Hash Join是非常重要的一条路径。</li>
</ul>

<h4 id="排序">排序</h4>

<p>​   排序也是一种对数据进行预处理的方法，它主要用在以下几个方面：</p>

<ul>
<li>借用排序可以实现分组操作，因为经过排序之后，相同的数据都聚集在一起，因此它可以用来实现分组。</li>
<li>B树索引的建立需要借助排序来实现。</li>
<li>物理连接路径Merge Join路径需要借助排序实现。</li>
<li>SQL语言中的Order By操作需要借助排序实现。</li>
</ul>

<p>在数据量比较小时，数据可以全部加载到内存，这时候使用内排序就能完成排序的工作，而当数据量比较大时，则需要使用外排序才能完成排序的工作，因此在计算排序的代价时需要根据数据量的大小以及可使用的内存的大小来决定排序的代价。</p>

<h4 id="物化">物化</h4>

<p>​   物化就是将扫描操作或者连接操作的结果保存起来，如果在中间结果比较大的情况下可能需要将结果写入外存，这会产生IO代价，因此这种保存是有代价的。</p>

<p>​   物化的优点是如果内表可以一次读取多次使用，那么就可以将这个中间结果保存下来多次利用，例如有t1表和t2表做连接，如果t2表作为内表经过扫描之后，只有5%的数据作为中间结果，其他95%的数据都被过滤掉了，那么就可以考虑将这5%的数据物化起来，这样t1表的每条元组就只和这5%的数据进行连接就可以了。
中间结果是否物化主要取决于代价计算的模型，通常物理优化生成物理路径时对物化和不物化两条路径都会计算代价，最终选择代价较低的一个。</p>

<h2 id="代价估算">代价估算</h2>

<p>​    优化器会根据生成的逻辑执行计划枚举出候选的执行路径，要确保执行的高效，需要在这些路径中选择开销最小、执行效率最高的路径。那么如何评估这些计划路径的执行开销就变得非常关键。代价估算就是来完成这项任务的，基于收集的数据统计信息，对不同的计划路径建立代价估算模型，评估给出代价，为路径搜索提供输入。</p>

<h3 id="统计信息">统计信息</h3>

<p>​   统计信息是计算计划路径代价的基石，统计信息的准确度对代价估算模型中行数估算和代价估算起着至关重要的作用，直接影响查询计划的优劣。openGauss支持使用Analyze命令语句来完成对全库、单表、列、相关性多列进行收集统计信息。</p>

<p>​   由于统计信息直接影响代价计算的准确度，所以统计信息的收集的频率就是一个非常敏感的参数，如果统计信息收集的频率太低，则会导致统计信息的滞后，相反，如果过于频繁的收集统计信息，则会间接影响查询的性能。</p>

<p>​   通常数据库管理系统会提供手动的收集统计信息的方法，openGauss支持通过Analyze命令来收集统计信息，同时数据库管理系统也会根据数据变化的情况自动决定是否重新收集统计信息，例如当一个表中的数据频繁的更新超过了一个阈值，那么就需要自动更新这个表的统计信息。在查询优化的过程中，如果优化器发现统计信息的数据已经严重滞后，也可以发起统计信息的收集工作。</p>

<p>​   表级的统计信息通常包括元组的数量（N）、表占有的页面数(B)，而列级的统计信息则主要包括属性的宽度(W)、属性的最大值(Max)、最小值(Min)、高频值(MCV)等等，通常针对每个列会建立一个直方图(H)，将列中的数据按照范围以直方图的方式展示出来，可以更方便的计算选择率。</p>

<p>​   直方图通常包括等高直方图、等频直方图和多维直方图等等，这些直方图可以从不同的角度来展现数据的分布情况，openGauss采用的是等高直方图，直方图的每个柱状体都代表了相同的频率。</p>

<h3 id="选择率">选择率</h3>

<p>​   通过统计信息，代价估算系统就可以了解一个表有多少行数据、用了多少个数据页面、某个值出现的频率等，然后根据这些信息就能计算出一个约束条件（例如SQL语句中的WHERE条件）能够过滤掉多少数据，这种约束条件过滤出的数据占总数据量的比例称为选择率。
$$
选择率 = 约束条件过滤后的元祖数量/约束条件过滤前的元祖数量
$$
​   约束条件可以是独立的表达式构成的，也可以是由多个表达式构成的合取范式或析取范式，其中独立的表达式需要根据统计信息计算选择率，合取范式和析取范式则借助概率计算的方法获得选择率。</p>

<p>合取范式：<code>P(A and B) = P(A) + P(B) – P(AB)</code>
析取范式：<code>P(AB) = P(A) × P(B)</code></p>

<p>​   假设要对约束条件A &gt; 5 AND B &lt; 3计算选择率，那么首先需要对A &gt; 5和B &lt; 3分别计算选择率，由于已经有了A列和B列的统计信息，因此可以根据统计信息计算出A列中值大于5的数据比例，类似的还可以计算出B列的选择率。假设A&gt;5的选择率为0.3，B<3的选择率为0.5，那么A > 5 AND B &lt; 3的选择率为：</p>

<pre><code>P(A&gt;5 and B&lt;3)
= P(A&gt;5) + P(B&lt;3) – P(A&gt;5)×P(B&lt;3)
= 0.3 + 0.5 – 0.3×0.5
= 0.65
</code></pre>

<p>​   由于约束条件的多样性，选择率的计算通常会遇到一些困难，例如选择率在计算的过程中通常假设多个表达式之间是相互“独立”的，但实际情况中不同的列之间可能存在函数依赖关系，因此这时候就可能导致选择率计算不准确。</p>

<h3 id="代价估算方法">代价估算方法</h3>

<p>​   openGauss的优化器是基于代价的优化器，对每条SQL语句，openGauss都会生成多个候选的计划，并且给每个计划计算一个执行代价，然后选择代价最小的计划。
​   当一个约束条件确定了选择率之后，就可以确定每个计划路径所需要处理的行数，并根据行数可以推算出所需要处理的页面数。当计划路径处理页面的时候，会产生IO代价，而当计划路径处理元组的时候（例如针对元组做表达式计算），会产生CPU代价，由于openGauss是分布式数据库，在CN和DN之间传输数据（元组）会产生通信的代价，因此一个计划的总体代价可以表示为：</p>

<pre><code>总代价 = IO代价 + CPU代价 + 通信代价
</code></pre>

<p>​   openGauss把所有顺序扫描一个页面的代价定义为单位1，所有其它算子的代价都归一化到这个单位1上。比如把随机扫描一个页面的代价定义为4，即认为随机扫描一个页面所需代价是顺序扫描一个页面所需代价的4倍。又比如，把CPU处理一条元组的代价为0.01，即认为CPU处理一条元组所需代价为顺序扫描一个页面所需代价的百分之一。
​   从另一个角度来看，openGauss将代价又分成了启动代价和执行代价，其中：</p>

<pre><code>总代价 = 启动代价 + 执行代价
</code></pre>

<ul>
<li><p>启动代价
从SQL语句开始执行，到此算子输出第一条元组为止，所需要的代价，称为启动代价。有的算子启动代价很小，比如基表上的扫描算子，一旦开始读取数据页，就可以输出元组，因此启动代价为0。有的算子的启动代价相对较大，比如排序算子，它需要把所有下层算子的输出全部读取到，并且把这些元组排序之后，才能输出第一条元组，因此它的启动代价比较大。</p></li>

<li><p>执行代价
从输出第一条元组开始，至查询结束，所需要的代价，称为执行代价。这个代价中又可以包含CPU代价、IO代价和通信代价，执行代价的大小与算子需要处理的数据量有关，与每个算子完成的功能有关。处理的数据量越大、算子需要完成的任务越重，则执行代价越大。</p></li>

<li><p>总代价
代价计算是一个自底向上的过程，首先计算扫描算子的代价，然后根据扫描算子的代价计算连接算子的代价以及Non-SPJ算子的代价。</p></li>
</ul>

<blockquote>
<p>注释</p>

<ol>
<li>SPJ：关系代数中最基本的3个算子：选择（SELECTION）、投影（PROJECTION）、连接（JOIN）:
Selection 选择，例如select xxx from t where xx = 5里面的where过滤条件。
Projection 投影，select c from t里面的取c列是投影操作。
Join 连接，select xx from t1, t2 where t1.c = t2.c就是把t1 t2两个表做Join。</li>
<li>Non-SPJ: 除SPJ算子外的排序（Sort）、聚集（Aggregation）、集合（UNION/EXCEPT）操作等算子。</li>
</ol>
</blockquote>

<h2 id="小结">小结</h2>

<p>​   本文主要从SQL解析器、查询重写、代价估算、路径搜索等方面讲解了SQL引擎各个模块的基本功能和原理，在此基础上大家可以结合具体的SQL优化案例分析来进一步加深对优化器优化技术的理解。</p>

                </div>
            </div>
            <div class="box" style="margin-top:15px;">
                <div style="font-size:14px;color:gray"><strong>【免责声明】</strong>本文仅代表作者本人观点，与本网站无关。本网站对文中陈述、观点判断保持中立，不对所包含内容的准确性、可靠性或完整性提供任何明示或暗示的保证。本文仅供读者参考，由此产生的所有法律责任均由读者本人承担。</div>
            </div>
            <div class="post-comment">
                
                  
  <link rel="stylesheet" href="https://xzx666.gitee.io/lookeng/css/custom.css" />
  <div id="vcomments" lang="zh-cn" mess="说点什么吧..."></div>

  <script type="text/javascript">
    const placeholder = document.getElementById("vcomments").getAttribute("mess"),
          lang = document.getElementById("vcomments").getAttribute("lang");
    const  langs = lang == "zh-cn" ? "zh-cn" : "en";
    new Valine({
        el: '#vcomments' ,
        appId: '6wfgavgIRqmpC3hjHqQVtFWF-gzGzoHsz',
        appKey: 'QRqrBDBB0p0YhrGe9IJ169ip',
        avatar:'mm', 
        placeholder: placeholder,
        visitor: true,
		    meta: ['nick','mail','link'],
        lang: langs
    });
  </script>
            </div>
        </div>
    </div>
</div>
<script>
    $(function (){
        var query = new AV.Query('Counter');
        query.equalTo('url', decodeURIComponent('\/zh\/post\/kangyang\/opengauss%E6%95%B0%E6%8D%AE%E5%BA%93%E6%A0%B8%E5%BF%83%E6%8A%80%E6%9C%AF-sql%E5%BC%95%E6%93%8E2\/'));
        query.find().then(function (data) {
            if(data.length && (data[0].attributes.author === 'openGauss')){
                var counter = AV.Object.createWithoutData('Counter', data[0].id);
                counter.set('author', 'kangyang');
                counter.save();
            }
        })
    })
</script>







<input id="iframeUrl" type="text" style="display: none;" value=https://xzx666.gitee.io/>




<script defer src="https://xzx666.gitee.io/lookengjs/all.js"></script>
<script src="https://xzx666.gitee.io/lookengjs/flexible.js"></script>
<script>
  const hash = window.location.search,
        pageurl = window.location.href;
  var langss = document.querySelector("html").lang === "zh-cn" ? "zh" : "en";
  console.log("hash:",hash,"pageurl:",pageurl,"ttr",pageurl.split(langss + "/")[1])

  if(!document.getElementById("vcomments")) {
    new Valine({
        appId: '6wfgavgIRqmpC3hjHqQVtFWF-gzGzoHsz',
        appKey: 'QRqrBDBB0p0YhrGe9IJ169ip',
        avatar:'mm',
        visitor: true,
		    meta: ['nick','mail','link']
    });
  }
 
  
    


    const url = document.getElementById("iframeUrl").value;

    function observe (el, options, callback) {
      var MutationObserver = window.MutationObserver || window.WebKitMutationObserver || window.MozMutationObserver
      var observer = new MutationObserver(callback)
      observer.observe(el, options)
    }

    var options = {
        childList: true,
        subtree: true,
        characterData: true
      }
    observe(document.body, options, (records, instance) => {
    const height = document.body.scrollHeight;
    parent.postMessage(height,url);
    })
    if(pageurl.split(langss + "/")[1]) parent.postMessage(pageurl.split(langss + "/")[1],url);
    

    if(document.querySelector("#notFound")) parent.postMessage("我404了",url);

</script>
</body>
</html>
